Object-oriented programming

• 在之前，我們使用的 programming 的方式會被稱為：procedural programming。
• 而在學會 objected-oriented programming 是一種基於 procedural programming 的延伸，但是兩者的不同是「觀點的不同」。
• 在 C裡面，通常會用 structure；而在 c++ 裡面則是使用 classes
• classes 就與 structure 一樣，可以讓我們自定義 data type，而在 class 裡面的變數則會被稱為 objects
• 使用 class / OOP 可以讓程式更好的模組化，在大型程式裡面會使用的比較多。

Outline

• Basic concepts
• Constructors and the destructor
• Friends and static members
• Object pointers and the copy constructor

Basic concepts

之前有寫過一個 Point 的 structure (其實就是二維陣列上的向量)

那我們今天來做一個 multi-dimensional vector

struct MyVector
{
	int n; 
	int* m; // 為了要動態的儲存 因為是 n 維向量，你不知道會是多少
	void init(int dim);
	void print();
};

void MyVector::init(int dim) // dim = dimension
{
	n = dim;
	m = new int[n];
	for (int i = 0; i < n; ++i) // initialization
		m[i] = 0;
}

void MyVector::print(
{
	cout << "(";
	for (int i = 0; i < n - 1; ++i)
		cout << m[i] << ", ";
	cout << m[n - 1] << ")\n";
}

int main()
{
	MyVector v;
	v.init(3);
	v.m[0] = 3;
	v.print(); // (3, 0, 0)
	delete [] v.m;
	return 0;
}

這樣子寫其實已經可以滿足我們原本想要的需求，但是還是有幾個缺點

• 如果今天你是跟同學一起寫這段程式的話，他們可能會忘記 initialize vector，這樣我們就不知道 m 會指向哪裡了。
• 同學也可以不用你的 print ，自己再寫一個 for loop 去 cout
• n 跟 m 亂用
• 忘記 delete

所以我們可能希望我們寫的 structure 可以

• initializer 可以自動地被呼叫
• vector 只能用我們的方式印
• n 、m 不能被分離式的修改(修 n 時 m 也會被修)
• 動態配置的空間可以自動被釋放掉

這時候 class 就可以派上用場了，因為它可以:

• member function 一定會被自動呼叫
• 可以 hide 一些 member ，還有放一些 public member
• ...還有更多

在使用之前，我們必須先知道:

variable 分為兩種

• Instance variables (default)
• Static variables

function 分為兩種

• Instance functions (default)
• Static functions

Definition of class

• class 可以說是把 struct 做一點改變而已。但是如果你直接把上面的程式中的 struct 改成 class

class MyVector
{
	int n; 
	int* m; // 為了要動態的儲存 因為是 n 維向量，你不知道會是多少
	void init(int dim);
	void print();
};

void MyVector::init(int dim) // dim = dimension
{
	n = dim;
	m = new int[n];
	for (int i = 0; i < n; ++i) // initialization
		m[i] = 0;
}

void MyVector::print(
{
	cout << "(";
	for (int i = 0; i < n - 1; ++i)
		cout << m[i] << ", ";
	cout << m[n - 1] << ")\n";
}

int main()
{
	MyVector v;
	v.init(3);
	v.m[0] = 3;
	v.print(); // (3, 0, 0)
	delete [] v.m;
	return 0;
}

這時候你會發現，好像沒辦法 compile

主要是因為 class 需要設定 visbility (class 與 struct 最大差別)

我們必須在 class 裡面設定三種 member

• Public : 可以在任何時候呼叫
• Private : 只能在 class 裡面呼叫
• Protected : 未來可能會遇到

在預設值下，所有的 member 都是 private，所以我們要做打開或是關起來這件事情。

就像這樣:

class MyVector
{
private:
	int n; 
	int* m; // 為了要動態的儲存 因為是 n 維向量，你不知道會是多少
public:	
	void init(int dim);
	void print();
};

void MyVector::init(int dim) // dim = dimension
{
	n = dim;
	m = new int[n];
	for (int i = 0; i < n; ++i) // initialization
		m[i] = 0;
}

void MyVector::print(
{
	cout << "(";
	for (int i = 0; i < n - 1; ++i)
		cout << m[i] << ", ";
	cout << m[n - 1] << ")\n";
}

int main()
{
	MyVector v;
	v.init(5); // 這時候就可以
	v.m[0] = 3;
	v.print(); // (3, 0, 0)
	delete [] v.m; // 這樣不行
	return 0;
}

像是在 main function 裡面，如果我們要存取 init 這個函數，因為我們已經把它改成 public ，因此如果你宣告他就可行，但是下面的 delete [] v.m ，因為我們把 m 設置成 private ，這時候就不能叫到他了(只能在 class 裡面存取他)。

data hiding (Encapsulation 封包)**

• 為什麼要設置 private ? 原因是因為我們想要保障 n、m 不會被亂動，程式才不會出錯。
• 同理，設置 public 的原因，也是想要限制使用者不要亂用其他的方式，像是用 cout << + for loop 而不是我們自己寫出來的 print。
• 在 99.9% 的情況下， instance variable 會被設為 private， instance function 會被設為 public。

簡單說，我們把一坨東西封包起來(像是手機或是電視)，再告訴使用者要怎麼使用(說明書)，你沒辦法拿他做其他的事情(就像是電視就只能看電視)。

Instance function overloading: (函式多載)

也就是說可以傳入多種情況，函式都可以運行，且可做不同結果

class MyVector
{
private:
	int n; 
	int* m; // 為了要動態的儲存 因為是 n 維向量，你不知道會是多少
public:	
	void init();
	void init(int dim);
	void init(int dim, int value)
};

void MyVector::init()
{
	n = 0;
	m = nullptr;
}

void MyVector::init(int dim) // dim = dimension
{
	init(dim, 0);
}

void MyVector::init(int dim, int value)
{
	n = dim;
	m = new int[n];
	for (int i = 0; i < n; i++)
		m[i] = value;
}

除此之外，class 也可以:

• 把object 丟進去其他 function，或是做為回傳值。
• 在其他的 class 裡面使用自定義的 class 作為 data type。(class 中的 class)

Constructors and the destructor

還記得我們剛剛想要完成的幾件事嗎?

• [ ] initializer 可以自動地被呼叫
• [x] vector 只能用我們的方式印
• [x] n 、m 不能被分離式的修改(修 n 時 m 也會被修)
• [ ] 動態配置的空間可以自動被釋放掉

我們目前大概只完成了第2 3 項，1 4 則需要下面的方式來達成。

Constructors 建構子 :

他是一個在 class 中的 function，可以做到: (在物件被建立的時候)

• 自動的呼叫
• 不能重複呼叫
• 不能被手動的呼叫

因此他可以達成我們 自動呼叫且初始化的功能。

特性:

• Constructor 的名字就跟 class 一樣。

  class MyVector
  {
  private:
  	int n; 
  	int* m; 
  public:	
  	MyVector(); // Constructor
  	MyVector(int dim);
  	MyVector(int dim, int value)
  };
  

• 且他不會回傳任何東西(連 void 都沒有)。

• 可以 overloading

• 沒有 parameter 的 constructor (Myvector )會被稱為 default constructor，如果你沒有建立一個 constructor的話，系統會自己幫你建立一個(也就是說 class 裡面一定會做一個 constructor)，且裡面不會做任何事情

所以把 constructor 加到我們剛剛做的程式裡:

class MyVector
{
private:
	int n; 
	int* m; 
public:	
	MyVector init(); 
	MyVector inti(int dim, int value = 0); // 如果只傳一個 parameter -> value 用 0 來做
	void print;
};
MyVector::MyVector()
{
	n = 0;
	m = nullptr;
}

Myvector::Myvector(int dim, int value)
{
	n = dim;
	m = new int[n];
	for (int i = 0; i < n; i++)
		m[i] = value;
}

void Myvector::print()
{
	cout << "(";
	for (int i = 0; i < n - 1; ++i)
		cout << m[i] << ", ";
	cout << m[n - 1] << ")\n";	
}

使用:

int main()
{
	Myvector v1(1);
	Myvector v2(3, 8); // 現在宣告的時候就可以順便初始化
	v1.print();
	v2.print();
	return 0;
}

這樣子我們就可以做到自動的初始化了

剩下的 release 動態配置的空間則會使用到 destructor →

Destructors

destructors:

• (在物件被消滅的時候) 被呼叫
  • 被消滅的定義: variable 的生命週期結束。
• 需要他的原因是因為在 variable 生命週期結束的時候，我們不會有機會去對他做甚麼事情。
• 跟 constructor 一樣，destructor 也會自動地被系統呼叫(如果你沒有定義 destructor)。

Define:

• 在class() 前面加上 ~ 就可以宣告一個 destructor了。

class MyVector
{
private:
	int n; 
	int* m; 
public:	
	~MyVector();
};

MyVector::~Myvector()
{
	delete [] m;
}

MyVector::MyVector(int dim, int value)
{
	n = dim;
	m = new int[n];
	for (int i = 0; i < n; i++)
		m[i] = value;
}

int main()
{
	if (true)
		MyVector v1(1); 
	return 0;
}

如此一來，我們宣告一個 object 的時候，就不會發生 memory leak?

Order?

class A
{
public:
	A(){ cout << "A\n";}
	~A(){ cout << "a\n";}
};

class B
{
private:
	A a;
public:
	B(){ cout << "B\n";}
	~B(){ cout << "b\n";}
};

int main()
{
	B b;
	return 0;
}

螢幕會印出:

A
B
b
a

這就是如果有 class 包含在 class 裡面的 constructor 和 destructor 呼叫的順序。

Friends and static members

Getter and setter

在大多數的情況下，instance variable 會是 private 的，因此為了存取他們，我們必須使用 getter & setter 來對他們做一些事。

• getter 會回傳一個 private instance variable 的值
• setter 則可以更改他們的值

class MyVector
{
private:
	int n;
	int* m;
public:
	int getN { return n; }
	void setN(int v){ n = v; }
};

friends

我們可以想像，如果今天我們想要開一個權限(像是你手機的密碼)，你不可能會跟陌生人說吧，所以一定是開給你感情比較好的朋友。

朋友可以是:

• global function
• class

像是下面這個 class

class MyVector
{
	//....
friend void test();
friend class Test;
};

我們可以知道 friend 的幾個特性: (以上面為例):

• 在 test() 和 class Test 裡面，可以使用 MyVector 的 private members
• MyVector 無法使用 Test 的 private members (單向)(就跟交朋友一樣?)
• friend 可以在 private 或是 public宣告(沒差)

所以我們可以在 test 裡面使用 n

void test{
	MyVector v;
	v.n = 100; // 因為是朋友!
	cout << v.n
}

在 Test 裡面也可以使用:

class Test{
public:
	void test(MyVector){
		v.n = 203;
		cout << v.n;
	}
};

Static members

• 在 class 裡面，每一個 object 都擁有自己的 instance variables 和 functions。
  (這時候就會稱這些 variables & functions 是 object-specific)

• 但是反過來，member variable 或是 function 可以是一個 class 的屬性( attribute) 或是 operation。

  (這個時候這些 variable 和 function 就會被稱為 class specific)

  他們就會被稱為 static members (靜態成員: 保持不變)

舉個例子: 像是 windows 中的視窗，每一個視窗都是一個 object。這些視窗都有自己的名稱、自己專屬的大小 這些特性就會被稱為 object-specific attribute。而每一個視窗，都會有一些相同的東西，像是每個視窗都會有 title bar、這些 bar 都有一樣的顏色、都會有 — [ ] X (縮小 / 全螢幕/ 關閉) 等按鈕，這些他們擁有的相同屬性，就可以稱為一個 class-specific attribute。

class Window
{
private:
	int width;
	int height;
	int locationX;
	int locationY;
	int status; // 0: min, 1:usual, 2: max
	static int barColor; // 0: gray....
	//.....
public:
	static int getBarColor();
	static void setBarColor(int color);
	//....
};

另外，我們必須在 global 的環境下 初始化一個 static variable(因為全部都要用)，像是這樣:

int Window::barColor = 0; // default
int Window::getBarColor()
{
	return barColor; 
}
void Window::setBarColor(int color)
{
	barColor = color;
}

那如果我們要在 int main() 存取 static member要用

class name::member name

如果是要存取 instance 的 member:

object name.member name

使用 static member:

int main()
{
	Window w;
	cout << Window::getBarColor();
	cout << "\n";
	Window::setBarColor(1);
	return 0;
}

所以現在我們就有了四種 member type:

• instance variable & instance functions
• static variable & instance functions

他們倆者的關係是這樣:

• 在 instance function 裡面，可以存取 static members
• 但是在 static function 裡面，不可以存取instance member
• 我們也可以像: w.getBarColor() 這樣子透過 object 存取 static member，但是 非常不建議 這麼使用，最好用 class 呼叫他

!!寫程式好習慣!!

• 如果你今天要寫一個每一個 object 都要使用的特性或是 function，這時候就要使用 static member → 可以維持一致性，

• 不要 object 來呼叫 static member

• 盡量用 class 來呼叫:

  int Window::getBarColor()
  {
  	return Window::barColor;
  }
  

static members' function:

1. 剛剛我們知道了 static members 可以維持 object 的一致性
2. 他還有另一個功能就是可以 計算一個 object 被建立了幾次

instance :

找出有幾個人被 constuct

class A
{
private:
	static int count;
public:
	A() {A::count++; } // 因為被大家共用，所以只要有人被建立的時候，就++
	static int getCount(){ return A::count; }
};

int A::count = 0;

int main(int argc, char const *argv[])
{
	A a1, a2, a3;
	cout << A::getCount() << "n"; // 3 
	return 0;
}

instance:

找出有幾個人目前還活著(alive)

class A
{
private:
	static int count;
public:
	A() {A::count++; }
	~A() {A::count--; }
	static int getCount(){ return A::count; }
};

int A::count = 0; 

int main(int argc, char const *argv[])
{
	if (true)
		A a1, a2, a3;
	cout << A::getCount() << "n"; // 0
	return 0;
}

另外，在中間的那一行就是前面所說的，static variable 要在 global 初始化。

Object pointer

• 因為 class 是一種我們自定義的 data type

• 且 pointer 可以指向任何一種 data type

  • 因此 pointer 是可以指向一個 object 的。 (store the address of an object)

  instnace:

  int main()
  {
  	MyVector v(5);
  	MyVector* ptrv = &v; // object pointer
  	return 0;
  
  }
  

• object pointer 的使用?

  • 因為 pointer 就是存取 object (例如說 a ) 的位置(其實就是代表 a 的意思)，所以我們可以用 *ptrA 去存取 a 中的 function，像是這樣: (*ptrA).print()

  • 但是有另一個更簡單存取的方式，就是直接用 ->

    所以上面的存取就可以寫成 ptrA ->print();

• WHY OBJECT POINTERS?

  1. 當我們要做一個 object array 的時候，可以用 pointer 來延遲 constructor 的呼叫，就會害我們失去初始化的機會。

     像是這個:

     int main()
     {
     	MyVector v[3]; // an object array
     	v[0].print(); // run-time error 因為 m 是 nullptr
     	return 0;
     }
     

     如果我們先呼叫了v[3]，會因為我們沒辦法初始化，會導致 array 裡面n = 0, m = nullptr。

     所以可以用 Dynamic object arrays 這個方法來解決:

     • object pointer可以幫我們做 動態記憶體配置 ✅

     int main()
     {
     	MyVector* ptrV = new MyVector(5); //呼叫 constructor
     	ptrV->print();
     	delete ptrV;
     	return 0;
     }
     

     • 也可以做出一個 動態的 array

     ❌ 因為我們宣告了 5 個 object，可是只叫了一個 pointer

     int main()
     {
     	MyVector* ptrV = new MyVector[5]; // 宣告動態 array
     	ptrV[0].print(); // run-time error 
     	delete [] ptrV;
     	return 0;
     }
     

     ✅ 我們宣告了 5 個 pointer，每一次都 create一個 object，再去做 constructor (中間的 for loop)，就可以完成。

     int main()
     {
     	MyVector* ptrArray[5]; //no constructor invocation
     	for(int i = 0; i < 5; i++)
     		ptrArray[i] = new MyVector(i + 1); // constructor
     	ptrArray[0]->print();
     	// some delete statements
     	return 0;
     }
     

  2. Passing object into a function

     如果我們今天要寫一個程式，讓我們把每一個 vector 的質相加

     MyVector sum(MyVector v1, MyVector v2, MyVector v3 )
     {
     	// assume that their dimensions are identical
     	int n = v1.getN();
     	int* sov = new int [n]; //sov = sum of vectors
     	for (int i = 0; i < n; ++i)
     		sov[i] = v1.getM(i) + v2.getM(i) + v3.getM(i); // 把他們相加
     	MyVector sumOfVec(n, sov); // constructor -> 後面要寫
     	return sumOfVec;
     }
     
     int MyVector::getN() { return n; }
     int MyVector::getM(int i) { return m[i]; }
     MyVector::MyVector(int d, int v[]) // sov 是一個 array
     {
     	n = d;
     	for (int i = 0; i < n; ++i)
     		m[i] = v[i];
     }
     

     在這個程式裡面，有 4 個 MyVector object 被創造，但是如果有更多的 object ，這時候就有點麻煩。

     所以可以改成用 pointer 來寫:

     MyVector sum(MyVector* v1, MyVector* v2, MyVector* v3)
     {
     	int n = v1->getN();
     	int* sov = new int [n];
     	for (int i = 0; i < n; ++i)
     		sov[i] = v1->getM[i] + v2->getM[i] + v3->getM[i];
     	MyVector sumOfVec(n, sov);
     	return sumOfVec;
     }
     

     如此一來，我們就只需要創造一個 object 就好了。

     但是很有可能因為 object 不夠多，所以用 pointer 的時候花的時間會更多，這樣就不太划算，因此建議 object 比較少的時候可以直接使用 object 來比較快。

  3. Passing object references

     MyVector sum(const MyVector& v1,const MyVector& v2,const MyVector& v3)
     {
     	int n = v1->getN();
     	int* sov = new int [n];
     	for (int i = 0; i < n; ++i)
     		sov[i] = v1.getM[i] + v2.getM[i] + v3.getM[i];
     	MyVector sumOfVec(n, sov);
     	return sumOfVec;
     }
     

     同樣的，我們也可以傳入 reference ，而下面就把 references 當作一般變數，直接用 .getM[i] 就可以了。

     而在 argument 的部分，因為我們不想要這些 reference 被更改，所以我們要用 const 來保護他們不被更改。

     很多時候我們寫出來的程式，不是為了要做出甚麼功能，而是要避免一些事情的發生。

Copying an object

class A
{
private:
	int i;
public:
	A() { cout << "A"; }
};
void f(A a1, A a2, A a3)
{
	A a4;
}

int main()
{
	A a1, a2, a3; // AAA
	cout << "\n===\n";
	f(a1, a2, a3); // A
	return 0;
}

這段程式會傳出:

AAA
===
A

為什麼當我們呼叫 f 的時候，只會傳出 A 而已? 而不是傳出 4 個 A(4 次 constructor)

In general, when we pass by value, a local variable will be created.

• when we pass by value for an object, a local object is created.
• the constructor should be invoked.

int main()
{
	A a1, a2, a3; // AAA
	cout << "\n===\n";
	A a4 = a1; // nothing
	return 0;
}

那如果我們把程式改成這樣，就會甚麼東西都不會傳出。

這是因為:

Creating an object by "copying" and object is a special operation. It happens:

• when we pass an object into a function using call by value mechanism.

  f(a1, a2, a3);
  

• when we assign an object to another object.

  A a4 = a1;
  

• when we create an object with another object as the argument of the constructor.

  A a5(a1);
  

COPY CONSTRUCTOR

這一個機制會被稱為 "copy constructor" (也就是用 copy object 的方式來建立 object)(這也是一個 default copy constructor)，他甚麼事情都不會做。我們也可以手動的設定他要做甚麼事情:

• 在 C++ 裡面，copy constructor 的 parameter 一定要是 constant reference。
• 如果 calling by value，copy constructor 會被宣告無數(parameter)次。

class A
{
private:
	int i;
public:
	A() { cout << "A"; }
	A( const A& a) { cout << "a"; }
};

void f(A a1, A a2, A a3)
{
	A a4;
}

int main()
{
	A a1, a2, a3; // AAA
	cout << "\n===\n; // ===
	f(a1, a2, a3); // aaaA
	A a4(a1); // a
	A a4 = a1; // a
	return 0;
}

像是在 f(a1, a2, a3); 的時候，就會因為 copy constructor 被啟動，所以就會印出 a。而像下面的 A a4(a1);，也是會印出 a； A a4 = a1; 的結果也是相同的。

WHY COPY CONSTRUCTORS?

我們自己也可以手動的寫出 copy constructor，大概會長:

MyVector::MyVector(const MyVector& v)
{
	n = v.n;
	m = v.m;
}

Shallow copy :

這個就是一般的 default copy constructor 會做的事情(前提: member中沒有 array 或是 pointer)。

那如果有 array 或是 pointer，因為 m 這個指標是指向一塊空間，但是如果是一個 array 的話，就會產生不同的指標指向同樣的空間的情況。

int main()
{
	MyVector v1(5, 1);
	MyVector v2(v1); //??
}

這時候記憶體中會變成:

這時候如果我們改了 v1 的時候，v2 都會一起被改。

Deep copy:

為了避免我們上述講的情形，我們就需要在 copy 的時候把一個一個 element 改掉。

首先我們要手動的宣告一個 dynamic array， 讓 m 儲存他的地址。最後在把 v.m[i] 的值取出來。

MyVector::MyVector(const MyVector& v)
{
	n = v.n;
	m = new int[n]; // deep copy
	for(int i = 0; i < n; i++)
		m[i] = v.m[i];
}

心得

以前學 python 的時候碰到 class 的機率很少，幾乎沒寫過。
現在終於知道在幹嘛了。